x
Home / 🗃️ unorganized / general notes / The Internals of Robot Operating System

The Internals of Robot Operating System

Robot Operating System (ROS) is a project by the Open Source Robotics Foundation.

ROS 2 is the latest version of ROS.
ROS is released periodically as distributions, named alphabetically, like Android (in the past) and Ubuntu.

Build Systems

A note on Build Systems

In ROS parlance, the build systems are also referred to as meta-build systems. The line between a meta-build system and a build system is thin. A build system uses build scripts to automate building of multiple packages in a complex project. A meta-build system is used to generate the build scripts for one or more build systems in a project.

Basically, a build system in an abstraction over manually compiling, and a meta-build system is an abstraction over build systems. Generally, meta-build systems (GNU Autotools, CMake, Meson, Bazel, etc.) can also invoke the build systems by itself, which would be appropriate if the project contains multiple build systems (GNU make, ninja, setuptools, etc.)

The build systems generally in ROS depend on the CMake build system, but since ROS packages can have more complex dependency chains, a more abstract build system had to be defined to handle the dependencies, using a standardized dependency manifest, named package.xml.

ROS 1

  • rosbuild (Original, and now deprecated ROS build system)
  • catkin (A general purpose build system, named as a reference to Willow Garage where it was developed)

ROS 2

  • ament (A synonym for catkin)
    • ament_packages: Parses package.xml files and looks for those packages in the local filesystem.
    • ament_cmake: A repository that contains packages related to building the CMake and setuptool projects.
    • ament_lint: Linter
    • ament_tools: This defines the interfaces by which we can access ament, such as ament build.
  • colcon (Stands for Collective Constructor, and it can handle ament and catkin packages)

Import Infrastructure

Unreleased Source Lists

Dependency List File Formats

  • .rosinstall files: Supported by rosinstall, rosws, wstools and vcstool. Generated by rosintall_generator.
  • .repo files: Supported by vcstool as the native dependency list format. Generated by vcstool export.

Tools

  • rosinstall (First, based on vcstools)
  • rosws (Second)
  • wstools (Third, based on vcstools)
  • vcstool (Fourth, Not the same as vcstools. ROS independent SCM general tool)

Released Dependency Lists

Dependency List File Formats

  • package.xml files: Supported by the Catkin / Ament build systems

Tools

  • rosdep: Looks at package.xml files in the local directory and installs all dependencies using the system package manager, either from the ROS Build Farm (by referring rosdistro keys, that is, the package references) or from the system repository.

Build Tools

  • catkin_tools: Catkin build tools, for ROS 1
  • ament_tools: Ament build tools, for ROS 2
  • colcon: Collective Construction, a universal build tool for ROS 1 and ROS 2

rosdep: Can install both system packages (APT, DNF, etc.) and ROS packages (https://packages.ros.org). It can see if dependencies are already in the workspace too.

rosdep source.d.list lists were used only prior to ROS 1: Groovy.
From that point on, rosdistro index.yaml was being used to set distro specific package lists.
index.yaml is now on format version 3 and 4.

rosdep: rosdistro index.yaml points to the ROS distro distribution.yaml, which lists the repositories. For each repository listed, there would be lists of the packages contained within them, the source repository's URL (VCS URL) and the release repository's URL (ROS Build Farm release).

Each repository would hold a number packages, and as the metadata, the Build Farm release repository URL and the VCS source repository URL. Some release repositories are hosted in the ros-gbp GitHub organization, but not all.

ROS Distribution System

  • rosinstall_generator: Generates .rosinstall or .repo lists for a given repository from the rosdistro metadata files (index.yaml and ${distro}/distribution.yaml).

  • vcstool: Fetches repositories based on the .rosinstall or .repo files.

  • rosdep: Recursively

  • ROS Build Farm

    • ros_buildfarm
  • bloom-generate

  • rosdistro: Holds metadata about packages built by ROS Build Farm, pushed by the bloom-generate command.

  • rosdistro Metadata Files:

    • index.yaml
    • ${distro}/distribution.yaml

  • ROS Dependency List Generator

    • rosinstall_generator: To generate generic dependency lists with metadata from rosdistro.
    • vcs export: To generate dependency lists from an existing workspace.

Commands

  • rosintall_generator (Or skip if you are using vcs_import directly)
  • vcs import ()
  • rosdep init (Initialize rosdistro source locations)
  • rosdep update (Update to the latest rosdistro cache)
  • rosdep install [--from-paths src -y] (Install dependencies based on package.xml files in the current project)
  • colcon build --packages-up-to (Local binary builds)
  • bloom-generate (ROS Build Farm builds)

ROS Buildfarm uses git-buildpackage (GBP) to build Debian and RPM source packages.
Then dpkg-buildpackage to build DEB packages from them (I guess after unpacking) (something else for RPM).
It internally calls fakeroot debian/rules binary, which we can directly call after unpacking the source DEB.

We can also call debian/rules binary after running bloom-generate rosdebian from a package's source directory. bloom-generate rosdebian does not make a source DEB, it simply makes it unpacked. bloom-release does the Git release and PR stuff.

checkinstall may also work in place of dpkg-buildpackage.

Buildbot-ROS is an addition to Build Farm.
More CIs: https://web.archive.org/web/20220124070453/[http://wiki.ros.org/CIs](https://web.archive.org/web/20220124070453/http://wiki.ros.org/CIs)

How to use

1. Install a ROS Underlay

Option 1. From APT/DNF

  • Add ROS APT/DNF Repository
  • Install a variant of ROS as the underlay

Option 2. From Source

  • Import base ROS environment sources, using a source import tool,
    • e.g. vcs import <path/to/ros-distro.repo>

  • Install the dependencies of the sources, based on their package.xml files, using a binary import tool.

    • e.g. rosdep init && rosdep update && rosdep install --from-paths src -y

2. Create ROS Overlays (workspaces)

  • Source the underlay environment variables
  • Create a workspace directory, with a folder named src in it
  • Add the required ROS package sources into the src directory
  • Run rosdep init && rosdep update && rosdep install --from-paths src -y
  • Build the workspace
    • Using Colcon (for ROS 1 and 2): colcon build
    • Using Ament (for ROS 2): ament build
    • Using Catkin (for ROS 1: Groovy and above)
      • Using catkin_tools: catkin build
      • Using catkin_make: catkin_make
      • Using catkin_make_isolated: catkin_make_isolated
    • Using rosbuild (For ROS 1, before Groovy): rosmake <package1> <package2> ...

rough

Israel-Palestine Rough

Hamas Terrorist:
We want Islamic Land:
My sons, Palestine will be Arabic!!!
Zionists are harming us!!!

My idea:

  • War was necessary. This is not a matter of justice, but about the rules of survival.
  • Jews wanted a dignified living, and Arabs denied them that, mocking them.

  • They won that war.

  • What can be done now is to exit the war and keep yourselves safe.

  • But yes, if you still want war, you can have it.
  • However, the nature of the war should be chosen properly.
  • If you put children in the battlefield, children will die.

  • If children decide to stay in the battlefield, they will die.

  • If those who fight the war attack without formal declaration, then that is terrorism.

  • Terrorism is unpredictable, and unprepared civilians will be harmed.
  • Therefore all terrorists must be surgically taken out (or captured).
  • Any casualty is acceptable in the neighborhoods of terrorist hideouts.

  • That is, surgically taking out terrorists is more important than avoiding casualty.

    • So any maneuver is acceptable for taking out terrorists.
    • But out of respect for civilians, they may choose to

    • But that depends on the level of danger posed by terrorism.

  • So if terrorists hide near civilians, civilians will die.

  • Justice is that Jews should have their historic religious identity.

  • Christians and Muslims are global citizens, and to them, any land is equal, except for cultural considerations of specific places as holy.

  • As for Palestinians, they could not handle a special Jewish homeland, that is why there had to be a war.

  • That is, while European Jews and Palestinians are Palestinians, Jews had a lost historic identity to that land, that was known by everyone.
  • And when the exiled and abused Jews needed a homeland for self-governance, the Christians and Muslims could not let them have it.
    • This itself means that they were not interested in the concerns of the Jews, although now that they've lost, they say that they've always lived together peacefully with the Jews.
    • The Jews of 19th century Palestine were mostly ultra-Orthodox Haredi Jews, who think secularism is antisemitism. They've also had gender separate schools.
    • Needless to say, their ways of life was extremely compatible with Islam. But by the ethical standards of 21st century, they would be considered primitive and insufferable.
    • So when the exiled Jews returned with European secular influence, the Arabs could not respect them as much as the Haredi Jews, and they would only be seen as immigrant dhimmis.
    • Also, alongside pan-Arabism, pan-Islamism was one of the plans for the Arab world. An influx of Jews would be against that goal.
    • Needless to say, pan-Islamism would be restrictive for the Christian and non-Abrahamic residents of Palestine.

About the land between the Jordan river and Mediterranean Sea:

  • In prehistory, it will be referred to as Israel or Judah
  • Prior to 2nd Century, it will be referred to as Judea
  • Prior to 8th Century, it will be referred to as Syria-Palestina or Roman Palestine.
  • By 19th Century, it will be referred to as the Palestine region of Ottoman Syria.
  • Prior to 1948, it was the Mandate for Palestine and the Hashemite Kingdom of Transjordan.
  • After 1948, it became Israel, Palestine and The Hashemite Kingdom of Jordan.

Tags

Left-click: follow link, Right-click: select node, Scroll: zoom
x